home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / test / test_cgi.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2005-10-18  |  7.1 KB  |  276 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. from test.test_support import verify, verbose
  5. import cgi
  6. import os
  7. import sys
  8.  
  9. class HackedSysModule:
  10.     argv = []
  11.     stdin = sys.stdin
  12.  
  13. cgi.sys = HackedSysModule()
  14.  
  15. try:
  16.     from cStringIO import StringIO
  17. except ImportError:
  18.     from StringIO import StringIO
  19.  
  20.  
  21. class ComparableException:
  22.     
  23.     def __init__(self, err):
  24.         self.err = err
  25.  
  26.     
  27.     def __str__(self):
  28.         return str(self.err)
  29.  
  30.     
  31.     def __cmp__(self, anExc):
  32.         if not isinstance(anExc, Exception):
  33.             return -1
  34.         
  35.         x = cmp(self.err.__class__, anExc.__class__)
  36.         if x != 0:
  37.             return x
  38.         
  39.         return cmp(self.err.args, anExc.args)
  40.  
  41.     
  42.     def __getattr__(self, attr):
  43.         return getattr(self.err, attr)
  44.  
  45.  
  46.  
  47. def do_test(buf, method):
  48.     env = { }
  49.     if method == 'GET':
  50.         fp = None
  51.         env['REQUEST_METHOD'] = 'GET'
  52.         env['QUERY_STRING'] = buf
  53.     elif method == 'POST':
  54.         fp = StringIO(buf)
  55.         env['REQUEST_METHOD'] = 'POST'
  56.         env['CONTENT_TYPE'] = 'application/x-www-form-urlencoded'
  57.         env['CONTENT_LENGTH'] = str(len(buf))
  58.     else:
  59.         raise ValueError, 'unknown method: %s' % method
  60.     
  61.     try:
  62.         return cgi.parse(fp, env, strict_parsing = 1)
  63.     except StandardError:
  64.         err = None
  65.         return ComparableException(err)
  66.  
  67.  
  68. parse_qsl_test_cases = [
  69.     ('', []),
  70.     ('&', []),
  71.     ('&&', []),
  72.     ('=', [
  73.         ('', '')]),
  74.     ('=a', [
  75.         ('', 'a')]),
  76.     ('a', [
  77.         ('a', '')]),
  78.     ('a=', [
  79.         ('a', '')]),
  80.     ('a=', [
  81.         ('a', '')]),
  82.     ('&a=b', [
  83.         ('a', 'b')]),
  84.     ('a=a+b&b=b+c', [
  85.         ('a', 'a b'),
  86.         ('b', 'b c')]),
  87.     ('a=1&a=2', [
  88.         ('a', '1'),
  89.         ('a', '2')])]
  90. parse_strict_test_cases = [
  91.     ('', ValueError("bad query field: ''")),
  92.     ('&', ValueError("bad query field: ''")),
  93.     ('&&', ValueError("bad query field: ''")),
  94.     (';', ValueError("bad query field: ''")),
  95.     (';&;', ValueError("bad query field: ''")),
  96.     ('=', { }),
  97.     ('=&=', { }),
  98.     ('=;=', { }),
  99.     ('=a', {
  100.         '': [
  101.             'a'] }),
  102.     ('&=a', ValueError("bad query field: ''")),
  103.     ('=a&', ValueError("bad query field: ''")),
  104.     ('=&a', ValueError("bad query field: 'a'")),
  105.     ('b=a', {
  106.         'b': [
  107.             'a'] }),
  108.     ('b+=a', {
  109.         'b ': [
  110.             'a'] }),
  111.     ('a=b=a', {
  112.         'a': [
  113.             'b=a'] }),
  114.     ('a=+b=a', {
  115.         'a': [
  116.             ' b=a'] }),
  117.     ('&b=a', ValueError("bad query field: ''")),
  118.     ('b&=a', ValueError("bad query field: 'b'")),
  119.     ('a=a+b&b=b+c', {
  120.         'a': [
  121.             'a b'],
  122.         'b': [
  123.             'b c'] }),
  124.     ('a=a+b&a=b+a', {
  125.         'a': [
  126.             'a b',
  127.             'b a'] }),
  128.     ('x=1&y=2.0&z=2-3.%2b0', {
  129.         'x': [
  130.             '1'],
  131.         'y': [
  132.             '2.0'],
  133.         'z': [
  134.             '2-3.+0'] }),
  135.     ('x=1;y=2.0&z=2-3.%2b0', {
  136.         'x': [
  137.             '1'],
  138.         'y': [
  139.             '2.0'],
  140.         'z': [
  141.             '2-3.+0'] }),
  142.     ('x=1;y=2.0;z=2-3.%2b0', {
  143.         'x': [
  144.             '1'],
  145.         'y': [
  146.             '2.0'],
  147.         'z': [
  148.             '2-3.+0'] }),
  149.     ('Hbc5161168c542333633315dee1182227:key_store_seqid=400006&cuyer=r&view=bustomer&order_id=0bb2e248638833d48cb7fed300000f1b&expire=964546263&lobale=en-US&kid=130003.300038&ss=env', {
  150.         'Hbc5161168c542333633315dee1182227:key_store_seqid': [
  151.             '400006'],
  152.         'cuyer': [
  153.             'r'],
  154.         'expire': [
  155.             '964546263'],
  156.         'kid': [
  157.             '130003.300038'],
  158.         'lobale': [
  159.             'en-US'],
  160.         'order_id': [
  161.             '0bb2e248638833d48cb7fed300000f1b'],
  162.         'ss': [
  163.             'env'],
  164.         'view': [
  165.             'bustomer'] }),
  166.     ('group_id=5470&set=custom&_assigned_to=31392&_status=1&_category=100&SUBMIT=Browse', {
  167.         'SUBMIT': [
  168.             'Browse'],
  169.         '_assigned_to': [
  170.             '31392'],
  171.         '_category': [
  172.             '100'],
  173.         '_status': [
  174.             '1'],
  175.         'group_id': [
  176.             '5470'],
  177.         'set': [
  178.             'custom'] })]
  179.  
  180. def norm(list):
  181.     if type(list) == type([]):
  182.         list.sort()
  183.     
  184.     return list
  185.  
  186.  
  187. def first_elts(list):
  188.     return map((lambda x: x[0]), list)
  189.  
  190.  
  191. def first_second_elts(list):
  192.     return map((lambda p: (p[0], p[1][0])), list)
  193.  
  194.  
  195. def main():
  196.     for orig, expect in parse_qsl_test_cases:
  197.         result = cgi.parse_qsl(orig, keep_blank_values = True)
  198.         print repr(orig), '=>', result
  199.         verify(result == expect, 'Error parsing %s' % repr(orig))
  200.     
  201.     for orig, expect in parse_strict_test_cases:
  202.         print repr(orig)
  203.         d = do_test(orig, 'GET')
  204.         verify(d == expect, 'Error parsing %s' % repr(orig))
  205.         d = do_test(orig, 'POST')
  206.         verify(d == expect, 'Error parsing %s' % repr(orig))
  207.         env = {
  208.             'QUERY_STRING': orig }
  209.         fcd = cgi.FormContentDict(env)
  210.         sd = cgi.SvFormContentDict(env)
  211.         fs = cgi.FieldStorage(environ = env)
  212.         if type(expect) == type({ }):
  213.             verify(len(expect) == len(fcd))
  214.             verify(norm(expect.keys()) == norm(fcd.keys()))
  215.             verify(norm(expect.values()) == norm(fcd.values()))
  216.             verify(norm(expect.items()) == norm(fcd.items()))
  217.             verify(fcd.get('nonexistent field', 'default') == 'default')
  218.             verify(len(sd) == len(fs))
  219.             verify(norm(sd.keys()) == norm(fs.keys()))
  220.             verify(fs.getvalue('nonexistent field', 'default') == 'default')
  221.             for key in expect.keys():
  222.                 expect_val = expect[key]
  223.                 verify(fcd.has_key(key))
  224.                 verify(norm(fcd[key]) == norm(expect[key]))
  225.                 verify(fcd.get(key, 'default') == fcd[key])
  226.                 verify(fs.has_key(key))
  227.                 if len(expect_val) > 1:
  228.                     single_value = 0
  229.                 else:
  230.                     single_value = 1
  231.                 
  232.                 try:
  233.                     val = sd[key]
  234.                 except IndexError:
  235.                     verify(not single_value)
  236.                     verify(fs.getvalue(key) == expect_val)
  237.  
  238.                 verify(single_value)
  239.                 verify(val == expect_val[0])
  240.                 verify(fs.getvalue(key) == expect_val[0])
  241.                 verify(norm(sd.getlist(key)) == norm(expect_val))
  242.                 if single_value:
  243.                     verify(norm(sd.values()) == first_elts(norm(expect.values())))
  244.                     verify(norm(sd.items()) == first_second_elts(norm(expect.items())))
  245.                     continue
  246.             
  247.     
  248.     env = {
  249.         'QUERY_STRING': 'x=1&y=2.0&z=2-3.%2b0&1=1abc' }
  250.     expect = {
  251.         'x': 1,
  252.         'y': 2.0,
  253.         'z': '2-3.+0',
  254.         '1': '1abc' }
  255.     d = cgi.InterpFormContentDict(env)
  256.     for k, v in expect.items():
  257.         verify(d[k] == v)
  258.     
  259.     for k, v in d.items():
  260.         verify(expect[k] == v)
  261.     
  262.     verify(norm(expect.values()) == norm(d.values()))
  263.     print 'Testing log'
  264.     cgi.log('Testing')
  265.     cgi.logfp = sys.stdout
  266.     cgi.initlog('%s', 'Testing initlog 1')
  267.     cgi.log('%s', 'Testing log 2')
  268.     if os.path.exists('/dev/null'):
  269.         cgi.logfp = None
  270.         cgi.logfile = '/dev/null'
  271.         cgi.initlog('%s', 'Testing log 3')
  272.         cgi.log('Testing log 4')
  273.     
  274.  
  275. main()
  276.